{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\ProgramData\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "\"\"\"A very simple MNIST classifier.\n",
    "See extensive documentation at\n",
    "https://www.tensorflow.org/get_started/mnist/beginners\n",
    "\"\"\"\n",
    "from __future__ import absolute_import\n",
    "from __future__ import division\n",
    "from __future__ import print_function\n",
    "\n",
    "import argparse\n",
    "import sys\n",
    "\n",
    "from tensorflow.examples.tutorials.mnist import input_data\n",
    "\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "#可视化\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "FLAGS = None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们在这里调用系统提供的Mnist数据函数为我们读入数据，如果没有下载的话则进行下载。\n",
    "\n",
    "<font color=#ff0000>**这里将data_dir改为适合你的运行环境的目录**</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From <ipython-input-2-1f2e3e29ecda>:3: read_data_sets (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:260: maybe_download (from tensorflow.contrib.learn.python.learn.datasets.base) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please write your own downloading logic.\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:262: extract_images (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting Mnist_data/train-images-idx3-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:267: extract_labels (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.data to implement this functionality.\n",
      "Extracting Mnist_data/train-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:110: dense_to_one_hot (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use tf.one_hot on tensors.\n",
      "Extracting Mnist_data/t10k-images-idx3-ubyte.gz\n",
      "Extracting Mnist_data/t10k-labels-idx1-ubyte.gz\n",
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\contrib\\learn\\python\\learn\\datasets\\mnist.py:290: DataSet.__init__ (from tensorflow.contrib.learn.python.learn.datasets.mnist) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use alternatives such as official/mnist/dataset.py from tensorflow/models.\n",
      "(55000, 784) (55000, 10)\n"
     ]
    }
   ],
   "source": [
    "# Import data\n",
    "data_dir = 'Mnist_data/'\n",
    "mnist = input_data.read_data_sets(data_dir, one_hot=True)\n",
    "print(mnist.train.images.shape,mnist.train.labels.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义各层神经元数量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "n_input_layer = 28 * 28  # 输入层\n",
    "n_output_layer = 10  # 输出层\n",
    "\n",
    "# 层数的选择：线性数据使用1层，非线性数据使用2层, 超级非线性使用3+层。层数、神经元过多会导致过拟合\n",
    "n_layer_1 = 1000  # hide layer\n",
    "n_layer_2 = 1300  # hide layer\n",
    "n_layer_3 = 800  # hide layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义3隐层神经网络\n",
    "def neural_network(x):\n",
    "    # 定义第一层\"神经元\"的权重和biases\n",
    "    layer_1_w_b = {'w_': tf.Variable(tf.truncated_normal([n_input_layer, n_layer_1])),\n",
    "                   'b_': tf.Variable(tf.truncated_normal([n_layer_1]))}\n",
    "    # 定义第二层\"神经元\"的权重和biases\n",
    "    layer_2_w_b = {'w_': tf.Variable(tf.truncated_normal([n_layer_1, n_layer_2])),\n",
    "                   'b_': tf.Variable(tf.truncated_normal([n_layer_2]))}\n",
    "    # 定义第三层\"神经元\"的权重和biases\n",
    "    layer_3_w_b = {'w_': tf.Variable(tf.truncated_normal([n_layer_2, n_layer_3])),\n",
    "                   'b_': tf.Variable(tf.truncated_normal([n_layer_3]))}\n",
    "    # 定义输出层\"神经元\"的权重和biases\n",
    "    layer_output_w_b = {'w_': tf.Variable(tf.truncated_normal([n_layer_3, n_output_layer])),\n",
    "                        'b_': tf.Variable(tf.truncated_normal([n_output_layer]))}\n",
    " \n",
    "    # w·x+b\n",
    "    layer_1 = tf.add(tf.matmul(x, layer_1_w_b['w_']), layer_1_w_b['b_'])\n",
    "    layer_1 = tf.nn.selu(layer_1)  # 激活函数 relu sigmoid  tanh elu  softplus\n",
    "    layer_2 = tf.add(tf.matmul(layer_1, layer_2_w_b['w_']), layer_2_w_b['b_'])\n",
    "    layer_2 = tf.nn.selu(layer_2)  # 激活函数\n",
    "    layer_3 = tf.add(tf.matmul(layer_2, layer_3_w_b['w_']), layer_3_w_b['b_'])\n",
    "    layer_3 = tf.nn.selu(layer_3)  # 激活函数\n",
    "    layer_output = tf.add(tf.matmul(layer_3, layer_output_w_b['w_']), layer_output_w_b['b_'])\n",
    " \n",
    "    return layer_output, layer_1_w_b, layer_2_w_b, layer_3_w_b, layer_output_w_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 每次使用100条数据进行训练\n",
    "batch_size = 100\n",
    "\n",
    "x = tf.placeholder(dtype=tf.float32, shape=[None, n_input_layer])   # 输入数据占位符\n",
    "y = tf.placeholder(dtype=tf.float32, shape=[None, n_output_layer])   # 输出数据占位符"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用数据训练神经网络\n",
    "def train_neural_network(X, Y, epochs=10):\n",
    "    #创建神经网络\n",
    "    y, layer_1_w_b, layer_2_w_b, layer_3_w_b, layer_output_w_b = neural_network(X)\n",
    "    #代价函数\n",
    "#     cost_func = tf.reduce_sum(tf.nn.softmax_cross_entropy_with_logits(logits= y, labels=Y))\n",
    "    cost_func = tf.reduce_sum(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=tf.argmax(Y,1), logits= y))\n",
    "    #惩罚因子\n",
    "    regularization_rate = 0.001\n",
    "    #计算L2正则化损失函数\n",
    "    regularizer = tf.contrib.layers.l2_regularizer(regularization_rate)\n",
    "    #将变量的L2正则化损失添加到集合中\n",
    "#     tf.add_to_collection(\"losses\",regularizer(layer_1_w_b['w_']))\n",
    "#     tf.add_to_collection(\"losses\",regularizer(layer_2_w_b['w_']))\n",
    "#     tf.add_to_collection(\"losses\",regularizer(layer_3_w_b['w_']))\n",
    "#     tf.add_to_collection(\"losses\",regularizer(layer_output_w_b['w_']))\n",
    "    regularization = regularizer(layer_1_w_b['w_']) + regularizer(layer_2_w_b['w_']) + regularizer(layer_3_w_b['w_']) + regularizer(layer_output_w_b['w_'])\n",
    "    \n",
    "    #将代价函数与正则项合并\n",
    "#     tf.add_to_collection(\"losses\",cost_func)\n",
    "    #获取整个模型的损失函数,tf.get_collection(\"losses\")返回集合中定义的损失\n",
    "    #将整个集合中的损失相加得到整个模型的损失函数\n",
    "#     loss = tf.add_n(tf.get_collection(\"losses\"))\n",
    "    loss = cost_func + regularization\n",
    "\n",
    "    #学习速率，随迭代次数进行递减\n",
    "    global_step = tf.Variable(0, trainable=False)\n",
    "    #设置基础学习率\n",
    "    starter_learning_rate = 0.0005\n",
    "    #设置学习率的衰减率\n",
    "    learning_rate_decay = 0.95\n",
    "    #设置指数衰减学习率\n",
    "    learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step, mnist.train.num_examples/batch_size/2, learning_rate_decay)\n",
    "    \n",
    "    train_step = tf.train.RMSPropOptimizer(learning_rate).minimize(loss)  \n",
    "    # AdamOptimizer RMSPropOptimizer 表现最好\n",
    "    # AdamOptimizer GradientDescentOptimizer AdadeltaOptimizer FtrlOptimizer ProximalGradientDescentOptimizer \n",
    "    # ProximalAdagradOptimizer RMSPropOptimizer\n",
    "    \n",
    "    #每迭代一次需要更新神经网络中的参数\n",
    "    train_op = tf.group(train_step)\n",
    " \n",
    "    with tf.Session() as session:\n",
    "        session.run(tf.initialize_all_variables())\n",
    "        \n",
    "        correct = tf.equal(tf.argmax(y, 1), tf.argmax(Y, 1))\n",
    "        accuracy = tf.reduce_mean(tf.cast(correct, 'float'))\n",
    "        \n",
    "        epoch_loss = 0\n",
    "        epoch_loss_mat = []\n",
    "        epoch_accuracy_mat = []\n",
    "        epoch_accuracy_t_mat = []\n",
    "        for epoch in range(epochs):\n",
    "            for i in range(int(mnist.train.num_examples / batch_size)):\n",
    "                batch_xs, batch_ys = mnist.train.next_batch(batch_size)\n",
    "                _, cost_vel = session.run([train_op, loss], feed_dict={X: batch_xs, Y: batch_ys, global_step:i*(epoch+1)})\n",
    "                epoch_loss += cost_vel\n",
    "            epoch_accuracy = accuracy.eval({X: mnist.train.images, Y: mnist.train.labels})\n",
    "            epoch_accuracy_t = accuracy.eval({X: mnist.test.images, Y: mnist.test.labels})\n",
    "            print('epoch ', epoch, ' loss      : ', epoch_loss)\n",
    "            print('epoch ', epoch, ' accuracy  : ', epoch_accuracy)\n",
    "            print('epoch ', epoch, ' accuracy_t: ', epoch_accuracy_t)\n",
    "            epoch_loss_mat.append(epoch_loss)\n",
    "            epoch_accuracy_mat.append(epoch_accuracy)\n",
    "            epoch_accuracy_t_mat.append(epoch_accuracy_t)\n",
    "            epoch_loss = 0\n",
    " \n",
    "        \n",
    "        print('训练准确率: ', accuracy.eval({X: mnist.train.images, Y: mnist.train.labels}))\n",
    "        print('测试准确率: ', accuracy.eval({X: mnist.test.images, Y: mnist.test.labels}))\n",
    "        \n",
    "        plt.plot(range(epochs), epoch_loss_mat) \n",
    "        plt.xlabel('epochs')\n",
    "        plt.ylabel('epoch_loss')\n",
    "        plt.show() \n",
    "        \n",
    "        plt.plot(range(epochs), epoch_accuracy_mat, label='Train Accuracy') \n",
    "        plt.plot(range(epochs), epoch_accuracy_t_mat, label='Test Accuracy')\n",
    "        plt.legend()\n",
    "        plt.xlabel('epochs')\n",
    "        plt.ylabel('accuracy')\n",
    "        plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\ProgramData\\Anaconda3\\lib\\site-packages\\tensorflow\\python\\util\\tf_should_use.py:118: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.\n",
      "Instructions for updating:\n",
      "Use `tf.global_variables_initializer` instead.\n",
      "epoch  0  loss      :  347933532.0\n",
      "epoch  0  accuracy  :  0.9362909\n",
      "epoch  0  accuracy_t:  0.9221\n",
      "epoch  1  loss      :  138045014.890625\n",
      "epoch  1  accuracy  :  0.96654546\n",
      "epoch  1  accuracy_t:  0.9406\n",
      "epoch  2  loss      :  98752933.1015625\n",
      "epoch  2  accuracy  :  0.9712\n",
      "epoch  2  accuracy_t:  0.9414\n",
      "epoch  3  loss      :  81089861.0\n",
      "epoch  3  accuracy  :  0.98163635\n",
      "epoch  3  accuracy_t:  0.9452\n",
      "epoch  4  loss      :  72116052.8046875\n",
      "epoch  4  accuracy  :  0.9909091\n",
      "epoch  4  accuracy_t:  0.9529\n",
      "epoch  5  loss      :  66315149.2734375\n",
      "epoch  5  accuracy  :  0.9917273\n",
      "epoch  5  accuracy_t:  0.9537\n",
      "epoch  6  loss      :  63072049.640625\n",
      "epoch  6  accuracy  :  0.99423635\n",
      "epoch  6  accuracy_t:  0.9573\n",
      "epoch  7  loss      :  60994864.875\n",
      "epoch  7  accuracy  :  0.9963091\n",
      "epoch  7  accuracy_t:  0.9609\n",
      "epoch  8  loss      :  59200847.8359375\n",
      "epoch  8  accuracy  :  0.9968182\n",
      "epoch  8  accuracy_t:  0.9598\n",
      "epoch  9  loss      :  57802320.6484375\n",
      "epoch  9  accuracy  :  0.9984364\n",
      "epoch  9  accuracy_t:  0.9612\n",
      "epoch  10  loss      :  56751586.25\n",
      "epoch  10  accuracy  :  0.9976364\n",
      "epoch  10  accuracy_t:  0.9613\n",
      "epoch  11  loss      :  55833278.2734375\n",
      "epoch  11  accuracy  :  0.99863636\n",
      "epoch  11  accuracy_t:  0.9622\n",
      "epoch  12  loss      :  54894880.6484375\n",
      "epoch  12  accuracy  :  0.99887276\n",
      "epoch  12  accuracy_t:  0.9617\n",
      "epoch  13  loss      :  53863499.8125\n",
      "epoch  13  accuracy  :  0.9988\n",
      "epoch  13  accuracy_t:  0.9636\n",
      "epoch  14  loss      :  53184805.7890625\n",
      "epoch  14  accuracy  :  0.99938184\n",
      "epoch  14  accuracy_t:  0.9633\n",
      "epoch  15  loss      :  52277089.421875\n",
      "epoch  15  accuracy  :  0.99923635\n",
      "epoch  15  accuracy_t:  0.964\n",
      "epoch  16  loss      :  51612473.6640625\n",
      "epoch  16  accuracy  :  0.99905455\n",
      "epoch  16  accuracy_t:  0.9632\n",
      "epoch  17  loss      :  51148859.625\n",
      "epoch  17  accuracy  :  0.99947274\n",
      "epoch  17  accuracy_t:  0.9636\n",
      "epoch  18  loss      :  50226974.078125\n",
      "epoch  18  accuracy  :  0.99956363\n",
      "epoch  18  accuracy_t:  0.9628\n",
      "epoch  19  loss      :  49861074.875\n",
      "epoch  19  accuracy  :  0.9993273\n",
      "epoch  19  accuracy_t:  0.963\n",
      "训练准确率:  0.9993273\n",
      "测试准确率:  0.963\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_neural_network(X=x, Y=y, epochs=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "毫无疑问，这个模型是一个非常简陋，性能也不理想的模型。目前只能达到92%左右的准确率。\n",
    "接下来，希望大家利用现有的知识，将这个模型优化至98%以上的准确率。\n",
    "Hint：\n",
    "- 多隐层\n",
    "- 激活函数\n",
    "- 正则化\n",
    "- 初始化\n",
    "- 摸索一下各个超参数\n",
    "  - 隐层神经元数量\n",
    "  - 学习率\n",
    "  - 正则化惩罚因子\n",
    "  - 最好每隔几个step就对loss、accuracy等等进行一次输出，这样才能有根据地进行调整"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
